The Effect of Shear Flow on the Helfrich Interaction in Lyotropic Lamellar Systems

We study the effect of shear flow on the entropic Helfrich interaction in lyotropic surfactant smectic fluids. Arguing that flow induces an effective anisotropic surface tension in bilayers due to a combination of intermonolayer friction, bilayer collisions and convection, we calculate the reduction in fluctuations and hence the renormalised change in effective compression modulus and steady-state layer spacing. We demonstrate that non-permeable or slowly permeating membranes can be susceptible to a undulatory instability of the Helfrich-Hurault type, and speculate that such an instability could be one source of a transition to multilamellar vesicles.Comment: 14 pages, to appear in Eur Phys J

Intel Concurrent Collections for Haskell

Intel Concurrent Collections (CnC) is a parallel programming model in which a network of steps (functions) communicate through message-passing as well as a limited form of shared memory. This paper describes a new implementation of CnC for Haskell. Compared to existing parallel programming models for Haskell, CnC occupies a useful point in the design space: pure and deterministic like Evaluation Strategies, but more explicit about granularity and the structure of the parallel computation, which affords the programmer greater control over parallel performance. We present results on 4, 8, and 32-core machines demonstrating parallel speedups over 20x on non-trivial benchmarks

Safe zero-cost coercions for Haskell

Generative type abstractions – present in Haskell, OCaml, and other languages – are useful concepts to help prevent programmer errors. They serve to create new types that are distinct at compile time but share a run-time representation with some base type. We present a new mechanism that allows for zero-cost conversions between generative type abstractions and their representations, even when such types are deeply nested. We prove type safety in the presence of these conversions and have implemented our work in GHC

Deforestation for higher-order functional programs

Functional programming languages are an ideal medium for program optimisations based on source-to-source transformation techniques. Referential transparency affords opportunities for a wide range of correctness-preserving transformations leading to potent optimisation strategies. This thesis builds on deforestation, a program transformation technique due to Wadler that removes intermediate data structures from first-order functional programs. Our contribution is to reformulate deforestation for higher-order functional programming languages, and to show that the resulting algorithm terminates given certain syntactic and typing constraints on the input. These constraints are entirely reasonable, indeed it is possible to translate any typed program into the required syntactic form. We show how this translation can be performed automatically and optimally. The higher-order deforestation algorithm is transparent. That is, it is possible to determine by examination of the source program where the optimisation will be applicable. We also investigate the relationship of deforestation to cut-elimination, the normalisation property for the logic of sequent calculus. By combining a cut-elimination algorithm and first-order deforestation, we derive an improved higher-order deforestation algorithm. The higher-order deforestation algorithm has been implemented in the Glasgow Haskell Compiler. We describe how deforestation fits into the framework of Haskell, and design a model for the implementation that allows automatic list removal, with additional deforestation being performed on the basis of programmer supplied annotations. Results from applying the deforestation implementation to several example Haskell programs are given

Web 2.0 and folksonomies in a library context

This is the post-print version of the Article. The official published version can be accessed from the link below - Copyright @ 2011 ElsevierLibraries have a societal purpose and this role has become increasingly important as new technologies enable organizations to support, enable and enhance the participation of users in assuming an active role in the creation and communication of information. Folksonomies, a Web 2.0 technology, represent such an example. Folksonomies result from individuals freely tagging resources available to them on a computer network. In a library environment folksonomies have the potential of overcoming certain limitations of traditional classification systems such as the Library of Congress Subject Headings (LCSH). Typical limitations of this type of classification systems include, for example, the rigidity of the underlying taxonomical structures and the difficulty of introducing change in the categories. Folksonomies represent a supporting technology to existing classification systems helping to describe library resources more flexibly, dynamically and openly. As a review of the current literature shows, the adoption of folksonomies in libraries is novel and limited research has been carried out in the area. This paper presents research into the adoption of folksonomies for a University library. A Web 2.0 system was developed, based on the requirements collected from library stakeholders, and integrated with the existing library computer system. An evaluation of the work was carried out in the form of a survey in order to understand the possible reactions of users to folksonomies as well as the effects on their behavior. The broad conclusion of this work is that folksonomies seem to have a beneficial effect on users’ involvement as active library participants as well as encourage users to browse the catalogue in more depth

Total Haskell is Reasonable Coq

We would like to use the Coq proof assistant to mechanically verify properties of Haskell programs. To that end, we present a tool, named hs-to-coq, that translates total Haskell programs into Coq programs via a shallow embedding. We apply our tool in three case studies -- a lawful Monad instance, "Hutton's razor", and an existing data structure library -- and prove their correctness. These examples show that this approach is viable: both that hs-to-coq applies to existing Haskell code, and that the output it produces is amenable to verification.Comment: 13 pages plus references. Published at CPP'18, In Proceedings of 7th ACM SIGPLAN International Conference on Certified Programs and Proofs (CPP'18). ACM, New York, NY, USA, 201